import java.util.Locale;
import java.util.SplittableRandom;

/**
 * Created with IntelliJ IDEA.
 * Description:对 String 类方法的学习
 */

class Student{
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Test {

    //关于String对象之间相加的过程
    //String 对象之间相加会创建一个 StringBuilder 对象，然后调用 toString() 方法返回 String 对象
    public static void main(String[] args) {
        String s1 = new String("ab");
        String s2 = new String("cd");
        String s3 = s1 + s2;
        System.out.println(s3);
    }
    //StringBuilder 与 StringBuffer 类
    //以上两个类都方便了字符串修改，但都不能直接赋值
    public static void main16(String[] args) {
        //StringBuffer
        //StringBuilder stringBuilder = "abcd"; //编译报错
        String s = "ab";
        StringBuilder stringBuilder = new StringBuilder(s);

        /*for (int i = 0; i < 100; i++) {
            stringBuilder.append(" " + i);
        }*/
        System.out.println(stringBuilder.charAt(0));
        //逆置
        stringBuilder.reverse();
        String substring = stringBuilder.substring(2);
        System.out.println(substring);
        System.out.println(stringBuilder);
        //想把 stringBuilder 转成 String 需要调用 toString 方法
        /*String s2 = stringBuilder.toString();
        System.out.println(s2);*/
    }

    //字符串常量池
    //String 对象创建
    // intern 方法
    public static void main15(String[] args) {
        char[] ch = new char[]{'a', 'b', 'c'};
        String s1 = new String(ch); // s1对象并不在常量池中
        //如果常量池中存在 s1 对象中的字符串，那么 s1的对象引用 将不会放入到常量池中
        s1.intern(); // s1.intern()；调用之后，会将s1对象的引用放入到常量池中
        String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
        System.out.println(s1 == s2);
    }
    //通过 new 创建 String 类对象
    public static void main14(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");
        //只要是 new 的对象，都是唯一的
        System.out.println(s1 == s2);
    }
    //直接使用字符串常量进行赋值
    public static void main13(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        System.out.println(s1 == s2);
    }

    //其他操作
    public static void main12(String[] args) {
        String s1 = new String("   hello world  !  ");
        //String trim()
        //去掉字符串中的左右空格,保留中间空格
        String str1 = s1.trim();
        System.out.println(s1);
        System.out.println("[" + str1 + "]");

    }

    //字符串截取
    public static void main11(String[] args) {
        String s1 = new String("abcdbcefabc");
        //String substring(int beginIndex)
        //从指定索引截取到结尾
        String str1 = s1.substring(5);
        System.out.println(str1);

        //String substring(int beginIndex, int endIndex)
        //截取部分内容，左闭右开
        String str2 = s1.substring(5,10);
        System.out.println(str2);
    }

    //字符串拆分
    public static void main10(String[] args) {
        /*String s = new String(", , , , ,        ab. sdf");
        String[] str1 = s.split(" ");
        System.out.println(str1);*/
        /*String s1 = new String("hello world and IDEA");
        //String[] split(String regex)
        //将字符串以形参字符串 regex 为边界全部拆分
        String[] str = s1.split(" ");
        for (String s: str) {
            System.out.println(s);
        }
        //部分拆分
        System.out.println("=================");
        String[] str2 = s1.split(" ",2);
        for (String s: str2) {
            System.out.println(s);
        }

        //拆分ip地址
        //字符"|","*","+"都得加上转义字符，前面加上 "\\"
        String s2 = new String("198.168.6.1");
        String[] str3 = s2.split("\\.");
        for (String s: str3) {
            System.out.println(s);
        }

        //如果一个字符串中有多个分隔符，可以用"|"作为连字符
        System.out.println("======================");
        String s3 = new String("abv.sajd?fj sd");
        String[] str4 = s3.split("\\.|\\?| ");
        for (String s: str4) {
            System.out.println(s);
        }*/

        //如果是 "\\" ，那么就得写成 "\\\\"
        //具体 Java 的"\"知识点查看默认收藏夹
        String s4 = new String("abc\\ade");
        System.out.println(s4);
        System.out.println("\\\\");
        String[] str5 = s4.split("\\\\");
        for (String s: str5) {
            System.out.println(s);
        }
    }

    //字符串替换
    public static void main9(String[] args) {
        //String replaceAll(String regex, String replacement)
        //字符串不能修改，只能重新创建一个新的字符串接收返回值
        //第一个形参是被修改的字符串，第二个形参是用来修改的字符串
        //替换所有指定内容
        String s1 = new String("abcabcbde");
        String s2 = s1.replaceAll("ab","pq");
        System.out.println(s2);

        //String replaceFirst(String regex, String replacement)
        //替换首个内容
        String s3 = s1.replaceFirst("ab","pq");
        System.out.println(s3);
    }

    //格式化
    public static void main8(String[] args) {
        String s = String.format("%d-%d-%d",2019,9,14);
        System.out.println(s);
    }

    //字符串与数组转换
    public static void main7(String[] args) {
        String s = "hello world";
        //字符串转数组
        char[] array = s.toCharArray();
        for (int i = 0; i < s.length(); i++) {
            System.out.print(array[i]);
        }
        System.out.println();
        //数组转字符串
        String s2 = new String(array);
        System.out.println(s2);
    }

    //大小写转换
    public static void main6(String[] args) {
        String s1 = "HELlo";
        String s2 = "HEllO";
        //小写转大写
        System.out.println(s1.toLowerCase());
        //大写转小写
        System.out.println(s2.toUpperCase());
    }

    //转化
    public static void main5(String[] args) {
        //数字转字符串
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.45);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new Student("zhangsan",20));
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println("==============================");
        //字符串转数字
        int data1 = Integer.parseInt("1234");
        double data2 = Double.parseDouble("12.34");
        System.out.println(data1);
        System.out.println(data2);
    }


    //字符串逆序查找
    public static void main4(String[] args) {
        String s1 = new String("abc as ghd hac ca gac");
        //int lastIndexOf(int ch)
        //从后往前找，返回ch第一次出现的位置，没有返回-1
        System.out.println(s1.lastIndexOf('a'));
        //int lastIndexOf(int ch, int fromIndex)
        //从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
        System.out.println(s1.lastIndexOf('h',10));
        //int lastIndexOf(String str)
        //从后往前找，返回str第一次出现的位置，没有返回-1
        System.out.println(s1.lastIndexOf("ac"));
        //int lastIndexOf(String str, int fromIndex)
        //从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1
        System.out.println(s1.lastIndexOf("ac",12));
    }

    //字符串顺序查找
    public static void main3(String[] args) {
        //char charAt(int index);
        //返回以 index 为下标的字符
        String s1 = "hello world!";
        System.out.println(s1.charAt(2));
        //int indexOf(char ch)
        //返回ch第一次出现的位置，没有返回-1
        System.out.println(s1.indexOf('w'));
        //int indexOf(int ch, int fromIndex)
        //从fromIndex位置开始找ch第一次出现的位置，没有返回-1
        System.out.println(s1.indexOf('o',5));
        //int indexOf(String str)
        //返回str第一次出现的位置，没有返回-1
        System.out.println(s1.indexOf("or"));
        //int indexOf(String str, int fromIndex)
        //从fromIndex位置开始找str第一次出现的位置，没有返回-1\
        String s2 = new String("abc bcd abd abc bbb");
        System.out.println(s2.indexOf("abc",5));

    }

    // String 对象按照字典序进行的比较
    public static void main2(String[] args) {
        String s1 = "hello world!";
        String s2 = new String("hello world!");
        String s3 = new String("hehe");
        String s4 = new String("Hehe");
        System.out.println(s1 == s2);
        //返回 boolean 类型
        System.out.println(s1.equals(s2));
        //返回 int 类型，
        //1.出现的第一个不同的字符之间的差值
        //2.当长度短的那个字符串遍历结束还没有找到不同的，返回两个字符串长度的差值
        System.out.println(s2.compareTo(s3));
        //与 compareTo 比较，忽略字母的大小写
        System.out.println(s3.compareToIgnoreCase(s4));
    }

    //字符串构造方法
    public static void main1(String[] args) {
        //使用常量串构造
        String s1 = "hello world!";
        //可以直接输出对象的原因就是在 String 类中重写了 toSting 方法
        System.out.println(s1);

        //使用 new String 对象
        String s2 = new String("hehe");
        System.out.println(s2);

        //使用字符数组进行构造
        char[] array = {'a','b','c','d'};
        String s3 = new String(array);
        System.out.println(s3);
    }

}
